Hilfstextedatei für MDEBUG V2.00
°Φúé╛&$╙(J,=$!#^ ─ !Hilfstext für MDEBUG V2.00 !─ $(c) Bernd Schemmer 1992 $─
 
 !Die Online-Hilfe kann jederzeit über die Taste F1 aufgerufen werden!
 
 !Tastenbelegung in der Online-Hilfe!
 
 $^Y ^X PgDn PgUp Home End$ - Hilfstext scrollen
 $ALT-1$..$ALT-9$  - setze Marker n $1$..$9$ - gehe zu Marker n
 $0$ - gehe zur letzten Position $ESC$,$F10$ - Online-Hilfe verlassen
 
 Die Marker$1$bis$9$ sind schon vorbelegt.$MDEBUG$zeigt in der$letzten$Zeile
 des Fensters die Position der Marker im Hilfstext an.
 Die Vorbelegungen der Marker sind wie folgt:
 
 !─ Marker ─ Online-Hilfe für . ─ !

 $1$ Tastenbelegung im Monitor

 $2$ Tastenbelegung bei der Eingabe des Suchstrings

 $3$ Tastenbelegung im Interpreter

 $4$ Tasten-Umbelegungen im Interpreter

 $5$ Befehle im Interpreter

 $6$ Erweiterungen durch den Treiber MDHISDRV

 $7$ Erweiterungen durch den Treiber MDDISDRV

 $8$ Bedeutung der Parameter
 !;─ !
 
 !Tastenbelegung im Monitor !
 
 $CTRL-PgUp$  - Fenster nach oben $CTRL-PgDn$ - Fenster nach unten
 $CTRL-F1$ - Programm-Pause $ALT-F9$ - Fenster neu aufbauen
 $F2$	 - Suchen eines Strings $SHIFT-F2$ - Suche wiederholen
 $F3$	 - Wechsel der akt. Spalte  $F4$
 - Interpreter aufrufen
 $F9$	 - lfd. Akt. ein/aus $F6$
 - akt. Adr. rest.
 $SHIFT-F6$ - akt. Adresse speichern $CTRL-F6$ - akt. Adr. tauschen
 $F8$	 - Monitor-Fenster an der akt. Stelle teilen
 $SHIFT-F8$ - unteres Monitor-Fenster schliessen
 $CTRL-F8$ - Monitor-Fenster vertauschen
 $CTRL-^Y$ - unteres Monitor-Fenster verkleinern
 $CTRL-^X$ - unteres Monitor-Fenster vergrössern
 $ALT-^Y ALT-PgDn ALT-^X ALT-PgUp$- unteres Monitor-Fenster scrollen
 $^X ^Y ^Z  PgDn PgUp$ - oberes Monitor-Fenster scrollen
 $+ -$(Nummernblock) - Inc./Dec. Offset der Monitor-Start-Adresse
 $ESC$ - Monitor verlassen $F10$	 - MDEBUG verlassen
 $sonst$ - Speicherstelle verändern (in Spalte 2 nur$0..9, A/a..F/f$)
 
 !Tastenbelegung bei der Eingabe des Suchstrings !
 
 $^Z  Delete Backspace Home End CTRL-End$- Eingabe editieren
 $CTRL-P$ - Prefixzeichen zur Eingabe von$ESC BS$und$Return$
 $Return$ - String suchen $ESC$	 - Eingabe abbrechen
 $■$(254xD) - Joker (passt immer) $sonst$ - Zeichen eingeben 
 
 !Befehle in der mittleren Monitor-Spalte !
 
 $O$ - direkte Eingabe des Offsets $S$ - direkte Eingabe des Segments
 $Z$ - akt. Wort für Offset nehmen $W$ - akt. Wort für Segment nehmen
 $P$ - akt. DWort f. Adresse nehmen  $M$ - ersten/nächsten MCB anzeigen
 $L$ - letzten MCB anzeigen
 $Y$ - nächsten MCB anzeigen
 $T$ - Offset der Cursorposition als Offset für die Start-Adresse nehmen
 $X$ - letzte Start-Adresse wieder benutzen, MDEBUG speichert die Start-

 Adresse des Monitors vor der Ausführung der Tasten$Z, W, P, L, Y,$
	 $T, M$und$X$im Monitor
$CTRL-B$- direkte Änderungen im Monitor erlauben/verbieten
 
 !Tastenbelegung im Interpreter !
 
 $CTRL-PgUp CTRL-PgDn$ - Fenster nach oben/unten verschieben
 $CTRL-F1$ - Programm-Pause
 $F2$ - akt. Monitor-Start-Adresse nach SE:OF und
 Register SE:OF als Monitor-Start-Adresse nehmen
 $SHIFT-F2$ - Register SE:OF als Monitor-Start-Adresse nehmen
 $F3 F4$ - Passwort-Abfrage ein/ausschalten
 $F9$ - lfd. Aktualisierung des Monitors ein/aus
 $SHIFT-F6$ - akt. Monitor-Adresse speichern
 $F6$ - akt. Monitor-Adresse restaurieren
 $CTRL-F6$ - akt. Monitor-Adresse tauschen
 $F7$ - Hilfsregister R1 bis R8 löschen
 $F8$ - Prozessor-Register restaurieren
 $SHIFT-F8$ - Prozessor-Register auf Werte von letzten Aufruf
 $ALT-F9$ - Fenster neu aufbauen
 $CTRL-^Y$ - unteres Monitor-Fenster verkleinern
 $CTRL-^X$ - unteres Monitor-Fenster vergrössern
 $ALT-^Y ALT-PgDn ALT-^X ALT-PgUp$- unteres Monitor-Fenster scrollen
 $+ -$(Nummernblock)	 - Inc./Dec. Offset der Monitor-Start-Adresse
 $CTRL-F8$ - Monitor-Fenster tauschen
 $ALT-F10$ - MDEBUG mit geänderten Registern verlassen
 $CTRL-F10$ - aktiven Prozess abbrechen (AL = Errorlevel)
 $ALT-F5$ - MDEBUG verlassen und warten bis DOS nicht mehr aktiv ist
 $F10$	 - MDEBUG verlassen $ESC$ - Rückkehr in den Monitor
 
 !Tasten-Umbelegungen im Interpreter !
 
 alt─neu─┬─alt─neu─┬─alt─neu─┬─alt─neu─┬─alt─neu
 $ä$ --> $«$ │ $ö$  --> $[$ │ $ü$  --> $$ │ $ß$  --> $¿$ │$CTRL-O$ --> $|$
 $Ä$ --> $»$ │ $Ö$  --> $]$ │ $Ü$  --> $^Z$ │ $_$  --> $¬$ │
 
 Die Original-Belegung und  Kleinbuchstaben  müssen nach  dem Prefix-Zeichen
$CTRL-P$eingegeben  werden.
 
 !Tastenbelegung bei der Befehls-Eingabe im Interpreter !
 
$#^$verkettet mehrere Befehle. $Signifikant$ist nur der$erste$und, falls vor-
 handen, der$letzte Buchstabe$der Befehle. Die Schreibweise (Groß/Klein) der
 Befehle muß beachtet werden. $Konstanten$und$Register$müssen immer in$Groß-
 buchstaben$angegeben werden.
 
 $CTRL-U$ - Upcase-Konvertierung ein- oder ausschalten
 $CTRL-Q$ - akustische Ausgaben ein- oder ausschalten
 $^Z  End Home CTRL-Cursortasten Delete Backspace$
 $Insert$ - Eingabe editieren
 $CTRL-End$ - Eingabe ab Cursor-Position bis zum Ende löschen
 $CTRL-Home$ - gesamte Eingabe löschen
 $Return$ - Eingabe bearbeiten
 $ALT-Return$
 - Eingabe bearbeiten, aber nicht in den internen Puffer
 übernehmen (- gilt nicht als letzter Befehl#!)
 $SHIFT-Return$ - Letzten Befehl neu editieren
 $CTRL-Return$	 - Letzten Befehl nochmal ausführen
 $^X ^Y PgDn PgUp$ - oberes Monitor-Fenster scrollen
 $ALT-End$
 - Original-Tastaturpuffer löschen
 
 !Befehle im Interpreter !
 
 $V$ reg1{,reg2} - Setzt reg1 als Segment-Register des Monitors und
 reg2, falls vorh., als Offset-Register des Monitors
 $?$ - Ausgabe:$AL$= User-Ints von MDEBUG $AH$= Aufrufmodus
 $BX$= Einstieg-Offset
 $^Z$ [reg1|wert2] {zu sichernde Zeichen} $^Z$
 - Sichert die Zeichen ab der angegebenen Adresse (1. Op.)
 $$ [reg2|wert2] - Restauriert den Eingabe-Puffer ab der ang. Adresse
 $H$[reg2|wert2] - Wie$$, aber geladenen Eingabe-Puffer sofort ausführen
 $D$ Mn
 - Memory-Speicher n anzeigen (0 <= n <= 9)
 $P$ [reg2|wert2] - Lädt die Monitor-Start-Adresse mit dem Doppelwort an
 der angegebenen Adresse
 $A$ [reg1|wert1],[reg2|wert2] - op1 := op1 + op2
 $a$ [reg1|wert1],[reg2|wert2] - op1 := op1 + op2 + CF
 $S$ [reg1|wert1],[reg2|wert2] - op1 := op1 - op2
 $s$ [reg1|wert1],[reg2|wert2] - op1 := op1 - op2 - CF
 $+$ [reg2|wert2] - op  := op + 1
 $-$ [reg2|wert2] - op  := op - 1
 $>$ [reg2|wert2] - op  := op SHR 1
 $<$ [reg2|wert2] - op  := op SHL 1
 $»$ [reg1|wert1],[reg2|wert2] - op1 := op1 SHR op2
 $«$ [reg1|wert1],[reg2|wert2] - op1 := op1 SHL op2
 $&$ [reg1|wert1],[reg2|wert2] - op1 := op1 AND op2
 $|$ [reg1|wert1],[reg2|wert2] - op1 := op1 OR op2
 $#!$ [reg1|wert1],[reg2|wert2] - op1 := op1 XOR op2
 $T$ [reg1|wert1],[reg2|wert2] - FLAGS := (op1 AND op2)
 $N$ [reg1|wert1] - op1 := NEG(op1)
 $M$ [reg1|wert1],[reg2|wert2] - op1 := op2
 $CY$ - CX Bytes von DS:SI nach ES:DI kopieren
 $I$ [reg|wert] - Interrupt op ausführen (00h <= op <= 0FFh)
 $G$ [reg|wert] - Maschinencode ab der Monitor-Start-Adresse
! ausf., op = Länge des Maschinencodes in Byte
 $B$ b1{{,}bn}{..}
 - Maschinencodes b1 .. bn ausführen
! bn = hex. Wert zwischen 00h und FFh
 Beispiele für den B-Befehl:
& n = $0$$1$$2$$3$$4$$5$$6$$7$
$F7,Fn$-  DIV regw $F7,En$-  MUL regw AX CX DX BX SP BP SI DI
$F6,Fn$-  DIV regb $F6,En$-  MUL regb AL CL DL BL AH CH DH BH
& m = $8$$9$$A$$B$$C$$D$$E$$F$
$F7,Fm$- IDIV regw $F7,Em$- IMUL regw AX CX DX BX SP BP SI DI
$F6,Fm$- IDIV regb $F6,Em$- IMUL regb AL CL DL BL AH CH DH BH
 
$EE$- OUT DX,AL $EF$- OUT DX,AX $E6,n$- OUT n,AL $E7,n$- OUT n,AX
$EC$- IN  AL,DX $ED$- IN  AX,DX $E4,n$- IN  AL,n $E5,n$- IN  AX,n
 
 $/$hilfreg - Speichern der akt. Monitor-Start-Adresse in den
 Hilfsregistern hilfreg und hilfreg+1
 $\$hilfreg - Restaurieren der akt. Monitor-Start-Adresse aus den
 Hilfsregistern hilfreg und hilfreg+1
 $##$hilfreg - Vertauschen der akt. Monitor-Start-Adresse mit den
 Hilfsregistern hilfreg und hilfreg+1
 $W$ - Register und Monitor aktualisieren und auf Tasten-
 druck warten ($<ESC>$ -> Bearbeitung abbrechen,
' $<BS>$ -> Eingabe neu bearbeiten)
 $H${[reg|wert]} - Eingabezeile wiederholt bearbeiten (reg/wert = Anzahl
 Warteschleifen nach jedem H-Befehl, Voreinst.: 0)
 $HN${[reg|wert]} - wie H-Befehl, aber kein Monitor-Update vor der Ausf.
 $¿$[reg|ausdruck] - Bearbeitung fortsetzen falls der Wert des Registers
 oder Ausdrucks ungleich 0 ist, ansonsten die Bearbei-
 tung abbrechen
 $¿H$[reg|ausdruck] - Bearbeitung fortsetzen falls der Wert des Registers
 oder Ausdrucks ungleich 0 ist, ansonsten die  Zeile
 noch mal von vorne bearbeiten
 $SH$ [{{¬}suchmaske}{|suchmaske}|{string }] {,} {.} 
 - Suche Bytes oder String ab der Monitor-Start-Adresse
 $F${n} - Monitor teilen (1 <= n <= 6, Anzahl Zeilen für das
 untere Fenster; falls n fehlt -> Teilung aufheben)
 $FX$ - Monitor-Fenster tauschen
 $Q$ - MDEBUG verlassen (wie Taste$<F10>$)
 $QR$ - MDEBUG verlassen mit autom. Rückkehr (wie$<ALT-F5>$)
 $QL$ - MDEBUG verlassen und Tastatur blockieren
 $#@$ - Kommentar (bis zum nächsten #^-Zeichen bzw. Ende)
 
 !Erweiterungen durch den Treiber MDHISDRV !
 
!Befehle:! (n ist jeweils eine Nummer im Intervall von '0' bis '9')
 $RB${name} - Lesen der Pufferinhalte aus der Datei 'name'
 $WB${name} - Sichern der Pufferinhalte in die Datei 'name'
 Beide Befehle sind nur bei möglich, falls$DOS nicht aktiv ist.$
 Voreinstellung für name ist$MDHISDRV.BUF$.
 $H=$ - Anzeige des Status der History-Funktion
 $H+$ - Einschalten der History-Funktion
 $H-$ - Ausschalten der History-Funktion
 $En$ - Editieren des Einzelpuffers mit der Nummer n
 $n:$ - Übernahme der Befehlszeile in den Einzelpuffer n
 Für$En$und$n:$gilt: Das Zeichen$#^$muß durch$~$angegeben werden.
 $Mn$ - Sofortiges Ausführen des Einzelpuffers n
 $MA$ - wie$Mn$, aber Nummer steht im Register$AL$
 $Ln$ - Löschen des Einzelpuffers n
 $LA$ - Löschen aller Puffer
 
!Tasten im Interpreter:!
 
 $CTRL-E$ - Restaurieren des letzten Befehls aus dem History-Puffer
 $CTRL-X$ - Restaurieren des nächsten Befehls aus dem History-Puffer
 $CTRL-D$ - Löschen des History-Puffers
 $CTRL-R$ - Einschalten der History-Funktion
 $CTRL-V$ - Ausschalten der History-Funktion
 $ALT-<n>$  - Sofortiges Ausführen des Einzelpuffers n
 
 !Erweiterungen durch den Treiber MDDISDRV !
 
!Befehle:!
 $DI${{s:}o} - Aufruf des DisAssemblers mit der Adresse s:o
 $DI$In - Aufruf des DisAssemblers mit der Adresse des Int n
 $DC${text} - Ausgabe des Strings 'text' auf den akt. Drucker
 des DisAssemblers (LPT1 . LPT9)
 $SM$ - Übernahme der Adresse des DisAssemblers in die
 Monitor-Register SE und OF
 
!Tasten im Monitor:!
 
 Aufruf des DisAssemblers mit .
 $F5$ - . der akt. Adresse
 $CTRL-F5$ - . der Adresse auf welcher der Cursor steht
 $ALT-F5$ - . dem  Wort auf dem der Cursor steht als Offset und dem 
 akt. Segment als Segment
 $SHIFT-F5$  - . dem Doppelwort an der Cursorposition
 
!Tasten im Interpreter:!
 
 Aufruf des DisAssemblers mit .
 $F5$ - . der akt. Adresse
 $SHIFT-F5$  - . der Ret-Adresse (Konstanten RS:RO)
 $CTRL-F5$ - . der Monitor-Start-Adresse
 
 !Bedeutung der Parameter !
 
$[reg|wert]$kennzeichnet eine Auswahl also entweder reg$oder$wert. Parameter
 in${}$sind optional; der Befehlsname muß  mit einem$Leerzeichen$enden;  die
 Parameter können durch$Komma$getrennt werden, führende Nullen sind nur beim
$B-$und$SH-Befehl$erforderlich.
$reg/reg1/reg2$ - Register-Name
 (AX..DX,DI,SI,SP,BP,DS,ES,SS,SP,BP,FL,R0..R8,SE,OF,FO,
 FS,AL,AH..DL,DH,0L,0H..8L,8H,0X..8X)
$hilfreg$ - Hilfsregister R0..R7
$wert/wert1/wert2$  - expliziter Wert oder String, auch als 1. Operand
 der verändert wird (Pseudo-Register)
$Dezimale$Werte  müssen durch ein  vorangestelltes Nummernzeichen$##$,$binäre$
 Werte  durch ein  vorangestelltes Dollar-Zeichen$#$$ gekennzeichnet werden.
 Zahlen mit einer Basis zwischen$2$und$15$können in der Form$b##n{..}$angege-
 ben werden, wobei$b$(2 .. F) die$Basis$und$n{..}$der$Wert$ist.  Alle Zahlen
 ohne Formatangaben  werden als$hexadezimale$Werte  interpretiert.  Negative
 Werte  müssen durch  ein Minuszeichen  (vor einen evtl.  Formatkennzeichen)
 gekennzeichnet werden. Zahlen können durch Punkte$.$formatiert werden.
 Folgende Konstanten können zusätzlich benutzt werden:
$CS$ - Code-Segment von$MDEBUG$
$RS$ - Segment der Rücksprungadresse $RO$ - Offset der Rücksprungadresse
$P1$ - Pseudoregister 1 $P2$ - Pseudoregister 2
$P3$ - Offset der Var. MDebugColors $P4$ - Offset der Var. MDebugCursor
$CS:*[P3]$= Interpreterfarbe,$CS:*[P3+1]$= Monitorfarbe
$DO$ - DOS-Busyflag verODERt mit dem Critical-Errorflag
$CU$ - Offset der akt. Cursorposition im Monitor
$Strings$müssen  in$'$oder  in$"$eingerahmt  sein (Länge max.$2$Zeichen, das
 Zeichen$#^$ist in einem String$nicht$möglich.)
 Explizite Werte  können auch$Ausdrücke$sein. Ein Ausdruck  besteht aus min.
 einem$Teil-Ausdruck$, welcher  eine arithmetische  oder logische  Operation
 mit 2 Operanden ist. Als Operanden für Teil-Ausdrücke sind$Register, expli-
$zite Werte, Konstanten$oder$Teil-Ausdrücke$möglich. Operatoren müssen immer
$zwischen$den Operanden stehen. Implementierte Operatoren für Teilausdrücke:
$+ - / \$(Modulo),$* & | #! « » %$ (Bit), $<$,$> = ¬$. Ausdrücke werden ohne
 eine Operatoren-Rangfolge  von$links nach rechts$bearbeitet. Klammerung ist
 möglich (max.$5$Klammerebenen). Falls  min.$1$Operand  eines Teil-Ausdrucks
 ein Byte-Wert ist, wird eine$Byte-Operation$ausgeführt.
$Adressierung von Speicherstellen$ (bei Parameter reg1/reg2/wert1/wert2):
 Durch die Angabe des Zeichens$[$vor einem Register, Wert oder Ausdruck wird
 das Wort bei der Adresse MonitorSegment:[reg1|wert]  angesprochen, das Zei-
 chen$*$spricht nur das Byte an.  Das voreingestellte  Segment-Register kann
 durch ein$Segment-Prefix$überschrieben  werden. Ein Segment-Prefix kann ein
$Register,$ein$expliziter Wert$oder ein$Ausdruck$sein.Segment-Prefixe müssen
 durch einen folgenden Doppelpunkt$':'$gekennzeichnet sein. (z.B. 'CS-1:03')
!N═ 
